


/**
 * 匹配课时
 * 只会出现带有附件的，减少匹配难度
 * @param {} data 
 * @param {*} json 
 * @returns 
 */
function buildSections(data, json) {
    // 存储最终的映射关系
    const mappings = {};
    // 先从demo.json获取所有课时ID和名称的对应关系
    const demoMappings = {};
    if (data.section) {
        Object.entries(data.section).forEach(([key, value]) => {
            demoMappings[value] = key;
        });
    }
    // 遍历original_data中的课时信息
    json.outlines.forEach(outline => {
        if (outline && outline.sections) {
            outline.sections.forEach(section => {
                if (section.details && section.details.length > 0) {
                    // 在demo.json中查找对应的课时ID
                    const demoSectionId = demoMappings[section.name];
                    if (demoSectionId) {
                        mappings[demoSectionId] = createSectionMapping(
                            section,
                            demoSectionId,
                            outline.name
                        );
                    }
                }
            });
        }
    });



// Object.keys(mappings).forEach(key => {
//     const item = mappings[key];
//     if(typeof item.minioInfos=='string'){
//         item.minioInfos=JSON.parse( item.minioInfos);
//     }
//   })
    // console.log("课时对应关系:", mappings);
    return mappings;
}
/**
 * 创建课时映射关系
 * @param {Object} section 课时信息
 * @param {string} demoSectionId demo.json中的课时ID
 * @param {string} outlineName 大纲名称
 * @returns {Object} 映射关系对象
 */
function createSectionMapping(section, demoSectionId, outlineName) {
    // 收集所有details中的minioInfos
    const allMinioInfos = section.details.reduce((acc, detail) => {
        if (detail.minioInfos) {
            acc.push(...detail.minioInfos);
        }
        return acc;
    }, []);


// 修复函数
function repairJSON(arr) {
    // 步骤1：合并字符数组
    let jsonStr = arr.join('');
  
    // 步骤2：修复常见JSON错误
    jsonStr = jsonStr
      .replace(/\\"/g, '"')    // 修正转义引号
      .replace(/,"}/g, '}')   // 移除对象尾部逗号
      .replace(/,"]/g, ']')   // 移除数组尾部逗号
      .replace(/"\s*:/g, '":'); // 修复键值分隔符
  
    // 步骤3：验证并返回结果
    try {
      return JSON.parse(jsonStr);
    } catch (e) {
      console.error('JSON修复失败:', e.message);
      return null;
    }
  }

    return {
        original_id: section.id,
        name: section.name,
        minioInfos:typeof allMinioInfos[0]==="string"? JSON.stringify(repairJSON(allMinioInfos)):JSON.stringify(allMinioInfos),
        outline_name: outlineName
    };
}

/**
 * 处理材料映射关系
 * @param {Object} materialData demo1中的material数据
 * @param {Object} jsonData demo2中的json数据
 * @returns {Object} 材料映射关系
 */
function buildMaterials(materialData, jsonData) {
    const materialMappings = {};
    // 遍历demo1中的material数据
 
    console.log(jsonData.materials);
    console.log(materialData);
    
    Object.entries(materialData).forEach(([materialId, fileName]) => {
 // 在json.materials中查找匹配的文件
        jsonData.materials.forEach(material => {
            // 定义匹配条件（可根据需要扩展）
            // 根据文件名字匹配

            const isNameMatch = material.name === fileName;
            // 这里要查找课程标准和授课计划匹配的文件，需要增加个条件指定type，不能只根据名字匹配，文件名字重复情况type类型会重复影响后面匹配(bug)，会造成授课计划，课程标准绑定的文件不会出现在资料列表中，但不影响查看，
            // 想到的解决方法：

            // 1，后端在materialData再返回的type,
            // 2,前端处理，找到type是3或者4的将其中一个的type改为1
            // 执行精确匹配
      
            
            if (isNameMatch) {
              materialMappings[materialId] = {
                id: materialId,
                name: fileName,
                minioInfo: {
                    url:material.url,
                    minioId:material.minioId,
                    type:material.type,
                    customName:material.name 
        }
              };
            }
          });    
// 在json.outlines中查找匹配的文件
        jsonData.outlines.forEach(outline => { 
            if (outline.sections) {
                outline.sections.forEach(section => {
                    if (section.details) {
                        section.details.forEach(detail => {
                       // 应用解析逻辑，判断是否为JSON字符串
                            if(typeof detail.minioInfos=='string'){
                                detail.minioInfos=JSON.parse(detail.minioInfos);
                            }    
                            if (detail.minioInfos) {
                                detail.minioInfos.forEach(info => {     
                                    if (info.customName === fileName) {
                                        materialMappings[materialId] = {
                                            id: materialId,
                                            name: fileName,
                                            minioInfo: info,
                                            outline_name: outline.name
                                        };
                                    }
                                });
                            }
                        });
                    }
                });
            }
        });
    });
  // 这样写如果有两个同名的material.name,但是material.type不一样,会造成精确匹配中返回的 materialMappings中的 minioInfo中的type是一样的,以下是前端的解决方法
  // 处理type为3和4的重复项
    const typeMap = new Map(); // 用于存储type为3和4的materialId
    Object.entries(materialMappings).forEach(([materialId, material]) => {
        const type = material.minioInfo.type;
        if (type === 3 || type === 4) {
            if (!typeMap.has(type)) {
                typeMap.set(type, materialId);
            } else {
                // 如果已经存在相同type，将当前项的type改为1
                materialMappings[materialId].minioInfo.type = 1;
            }
        }
    });

    console.log(materialMappings);
    return materialMappings;   
}

/**
 * 处理作业映射关系
 * @param {Object} operationData demo1中的operation数据
 * @param {Object} jsonData demo2中的json数据
 * @returns {Object} 作业映射关系
 */
function buildOperations(operationData, jsonData) {
    const operationMappings = {};

    // 遍历demo1中的operation数据
    Object.entries(operationData).forEach(([operationId, operationName]) => {
        // 在jsonData.operations中查找匹配的作业
        if (jsonData.operations) {
            jsonData.operations.forEach(operation => {
                if (operation.name === operationName) {
                    operationMappings[operationId] = {
                        id: operationId,
                        name: operationName,
                        original_id: operation.id,
                        content: operation.details?.[0]?.content || null,
                        minioInfos: JSON.stringify(operation.details?.[0]?.minioInfos || []),
                    };
                }
            });
        }
    });

    return operationMappings;
}


export function arrangeJSON(alreadyData, originalData) {
    // 如果导入的数据数组长度＞0 返回第一个原始，<0或不是数组返回本身或空对象
    
    
    let data = alreadyData.length > 0 ? alreadyData[0] : alreadyData ? alreadyData : {};
;
    let original = originalData.length > 0 ? originalData[0] : originalData ? originalData : {};

    if (original.original__data) {
        // 获取原始数据original__data，包含了大纲章节、小节、资料、作业
        let json = JSON.parse(original.original__data);
       
        let base = {
            id: data.bk_id,
            url: json["resource"].url,
            name: json["resource"].name,
            major: json["resource"].major,
        }
        // console.log("base:",json["resource_id"]);
        let sections = buildSections(data, json);
        let materials = data.material ? buildMaterials(data.material, json) : {};
        let operations = data.operation ? buildOperations(data.operation, json) : {};


        // console.log("base:",base); // 作业
        // console.log("sections:", sections); //课时
        // console.log("materials:", materials); // 资料
        // console.log("operations:", operations); // 作业


        /**
         * 
         * 
         
        、
1. 调用demo3.js【假设没bug】里面的逻辑，拿到想要更新的业务模块的对象，比如说现在要更新作业。 
operations: {
  '7278590697228345339': {
    id: '7278590697228345339',
    name: 'rttre',
    original_id: 2,
    content: '<p>retretr</p>',
    minioInfos: '[{"url":"http://120.224.9.197:51038/reslib-prod/dev_banke_zyk/other/2024/08/09/c90db8e4-f46d-4ffb-8a62-7b926fe07f26.png","size":"377084","minioId":"1821720136843747330","customName":"10.png"}]'
  }
}



2. 文件上传    获取fileid

3. 需要根据上传的文件名   1273818273.jpg 去匹配 operations里面也叫找个名称的对象 比如说上面的对象  

4. 取到id: '7278590697228345339', 即即将更新的业务id ，business_id 。 

5. 调用bind_file接口  
        传递   第四步的id   fileid   业务类型  文件类型  


6.go!

         */

        return {
            sections,
            materials,
            operations
        };
    }
    return null;
}